#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<string.h>
#include<string>
#include<unordered_map>
#define COMMAND_SIZE 1024
#define FORMAT "[%s@%s %s]# "

//下面是shell定义的全局数据

//提供了一个全局的 1.命令行参数表
#define MAXARGC 128
char *g_argv[MAXARGC];
int g_argc = 0;

//2.环境变量表
#define MAX_ENVS 100
char *g_env[MAX_ENVS];
int g_envs = 0;

//3. 别名映射表
std::unordered_map<std::string, std::string> alias_list;

// for test 
char cwd[1024];
char cwdenv[1024];

// last exit code 
int lastcode = 0;   //最近一个程序退出时的退出码

const char *GetUserName()
{
    //用getenv获取环境变量，获取用户名
    const char *name = getenv("USER");
    return name == NULL ? "None" : name;
}

//获取主机名
const char *GetHostName()
{
    const char *hostname = getenv("HOSTNAME");
    return hostname == NULL ? "None" : hostname;
}

//当前主机路径
//cwd或pwd都可以
//"cwd" 是 "current working directory" 的缩写，意为“当前工作目录”
const char *GetPwd()
{
    //const char *pwd = getenv("PWD");
    const char *pwd = getcwd(cwd, sizeof(cwd));
    //导环境变量,更新环境变量
    if(pwd != NULL)
    {
        snprintf(cwdenv, sizeof(cwdenv), "PWD=%s", cwd);
        //用putenv导入环境变量
        putenv(cwdenv);
    }
    return pwd == NULL ? "None" : pwd;
}

//获取环境变量的家目录
const char *GetHome()
{
    const char *home = getenv("HOME");
    return home == NULL ? "" : home;
    //return getenv("HOME");
}

void InitEnv()
{
    extern char **environ;
    memset(g_env, 0, sizeof(g_env));
    g_envs = 0;

    //本来要从配置文件来
    //现在从父shell来
    //1.获取环境变量
    for(int i = 0; environ[i]; i++)
    {
        //1.1申请空间
        g_env[i] = (char*)malloc(strlen(environ[i])+1);  //多申请一个放\0
        if(g_env[i] == NULL)
        {
            perror("malloc fail: ");
            exit(1);
        }
        //拷贝
        strcpy(g_env[i], environ[i]);
        g_envs++;
    }
    g_env[g_envs++] = (char*)"HAHA=for_test";   //for test
    g_env[g_envs] = NULL;
    
    //2.导成环境变量
    for(int i = 0; g_env[i]; i++)
    {
        putenv(g_env[i]);
    }
    environ = g_env;
}

//command
bool Cd()
{
    //cd argc == 1
    if(g_argc == 1)
    {
        std::string home = GetHome();
        //获取失败直接返回
        if(home.empty()) return true;
        chdir(home.c_str());
    }
    else 
    {
        std::string where = g_argv[1];
        // cd - / cd ~
        if(where == "~")
        {
            //进入家目录
            if(GetHome() == nullptr) return true;
            chdir(GetHome());
            
        }
        else if(where == "-")
        {
            //进入家目录
            if(GetHome() == nullptr) return true;
            chdir(GetHome());
        }
        else 
        {
            chdir(where.c_str());
        }
    }
    return true;
}

void Echo()
{
    if(g_argc == 2)
    {
        //echo "hello world"
        //echo $?
        //echo $PATH
        std::string opt = g_argv[1];
        if(opt == "$?")
        {
            std::cout << lastcode << std::endl;
            lastcode = 0;
        }
        else if(opt[0] == '$')
        {
            std::string env_name = opt.substr(1);
            //由于没有自己实现的环境变量表，直接用getenv传获取的环境变量名字，获取继承父进程的
            const char *env_value =  getenv(env_name.c_str());
            if(env_value)
                std::cout << env_value << std::endl;
        }
        else 
        {
            std::cout << opt << std::endl;
        }
    }
}

//路径处理
// /  /a/b/c
std::string DirName(const char *pwd)
{
#define SLASH "/"
    std::string dir = pwd;
    if(dir == SLASH) 
        return SLASH;
    auto pos = dir.rfind(SLASH);
    if(pos == std::string::npos) 
        return "BUG?";
    return dir.substr(pos+1);
}

//制作一个命令提示符
void MakeCommandLine(char cmd_prompt[], int size)
{
    //snprintf(cmd_prompt, size, "[%s@%s %s]# ",GetUserName(), GetHostName(), GetPwd());
    //用snprintf往字符串里打印
    snprintf(cmd_prompt, size, FORMAT, GetUserName(), GetHostName(), DirName(GetPwd()).c_str()); 
}

//打印命令行提示符
void PrintCommandPrompt()
{
    char prompt[COMMAND_SIZE];
    MakeCommandLine(prompt, sizeof(prompt));
    
    //命令行不需要带\n
    printf("%s", prompt);
    //保险起见刷新一下
    fflush(stdout);
}

//获取用户输入的命令
bool GetCommandLine(char *out, int size)
{
    //ls -a -l => "ls -a -l\n" 字符串
    //用fgets获取用户按行获取到目标字符串中
    char *c = fgets(out, size, stdin);
    //获取失败返回空
    if(c == NULL) return false;
    //获取成功返回该目标字符串的起始地址
    out[strlen(out)-1] = 0; //清理\n
    if(strlen(out) == 0) return false;
    return true;
}
//3. "ls -a -l" -> "ls" "-a" "-l" 命令行分析
bool CommandParse(char *commandline)
{
#define SEP " "
    g_argc = 0;
    // "ls -a -l" -> "ls" "-a" "-l" 命令行分析
    g_argv[g_argc++] = strtok(commandline, SEP);   //把ls截出来了
    
    while((bool)(g_argv[g_argc++] = strtok(nullptr, SEP)));

    g_argc--;
    return g_argc > 0 ? true : false;
}

void PrintArgv()
{
    for(int i = 0; g_argv[i]; i++)
    {
        printf("argv[%d]->%s\n", i, g_argv[i]);
    }
    printf("argc: %d\n", g_argc);
}

// 检测并处理内建命令
bool CheckAndExecBuiltin()
{
    std::string cmd = g_argv[0];
    if(cmd == "cd")
    {
        Cd();
        return true;
    }
    else if(cmd == "echo")
    {
        Echo();
        return true;
    }
    else if(cmd == "export")
    {

    }
    else if(cmd == "alias")
    {
        //std::string nickname = g_argv[1];
        //alias_list.insert(k,v);
    }
    return false;
}

//执行命令
int Execute()
{
   pid_t id = fork();
   if(id == 0)
   {
       //child
       //程序替换
       execvp(g_argv[0], g_argv);
       exit(1);
   }
    
   int status = 0;
   //father 
   pid_t rid = waitpid(id, &status, 0);
   if(rid > 0) //>0 等待成功获取到子进程的pid
   {
       //要的是子进程的退出码
       lastcode = WEXITSTATUS(status);
   }
   return 0;
}

int main()
{
    //shell启动的时候，需要从系统中获取环境变量
    //我们自己实现的做不到从系统读，但可以从父shell拿环境变量
    InitEnv();


    //不断的让用户输入
    while(true)
    {
        //1.输出命令行提示符
        PrintCommandPrompt();
        //printf("[%s@%s %s]# ", GetUserName(), GetHostName(), GetPwd()); 

        //2. 获取用户输入的命令
        char commandline[COMMAND_SIZE];
        //如果用户输入的是空的，也就是获取命令行获取失败了就重新获取
        if(!GetCommandLine(commandline, sizeof(commandline)))
            continue;

        //3. "ls -a -l" -> "ls" "-a" "-l"
        // 命令行分析
        if(!CommandParse(commandline))
            continue;
        //PrintArgv();
        
        //检测别名

        //4. 检测并处理内建命令，如cd这种
        if(CheckAndExecBuiltin())
            continue;

        //5. 执行命令
        Execute();
    }
    
    //cleanup();
    return 0;
}
